
import {
  Blob,
  btoa,
  createImageBitmap,
  CSSStyleDeclaration,
  performance,
  document,
  DOMParser,
  EventTarget,
  fetch,
  Headers,
  HTMLCanvasElement,
Image,
  HTMLImageElement,
  ImageBitmap,
  location,
  navigator,
  Request,
  requestAnimationFrame,
  cancelAnimationFrame,
  Response,
  URL,
  window,
  self,
  WebAssembly,
  Worker,
  XMLHttpRequest,
ImageData,
TextDecoder,
  core
  } from 'dhtml-weixin';
import {
ClampToEdgeWrapping,
DoubleSide,
LinearFilter,
Mesh,
MeshBasicMaterial,
PlaneGeometry,
Texture
} from '../../../three/Three';

/**
* This class has been made to hold a slice of a volume data
* @class
* @param   {Volume} volume    The associated volume
* @param   {number}       [index=0] The index of the slice
* @param   {string}       [axis='z']      For now only 'x', 'y' or 'z' but later it will change to a normal vector
* @see Volume
*/
class VolumeSlice {

constructor( volume, index, axis, callback ) {

  const slice = this;
  /**
   * @member {Volume} volume The associated volume
   */
  this.volume = volume;
  /**
   * @member {Number} index The index of the slice, if changed, will automatically call updateGeometry at the next repaint
   */
  index = index || 0;
  Object.defineProperty( this, 'index', {
    get: function () {

      return index;

    },
    set: function ( value ) {

      index = value;
      slice.geometryNeedsUpdate = true;
      return index;

    }
  } );
  /**
   * @member {String} axis The normal axis
   */
  this.axis = axis || 'z';

  /**
   * @member {HTMLCanvasElement} canvas The final canvas used for the texture
   */
  /**
   * @member {CanvasRenderingContext2D} ctx Context of the canvas
   */
  this.canvas = document.createElement( 'canvas' );
  /**
   * @member {HTMLCanvasElement} canvasBuffer The intermediary canvas used to paint the data
   */
  /**
   * @member {CanvasRenderingContext2D} ctxBuffer Context of the canvas buffer
   */
  this.canvasBuffer = document.createElement( 'canvas' );
  this.updateGeometry();

  const canvasMap = new Texture(this.canvas );
  canvasMap.minFilter = LinearFilter;
  canvasMap.wrapS = canvasMap.wrapT = ClampToEdgeWrapping;
  const material = new MeshBasicMaterial( { map: canvasMap, side: DoubleSide, transparent: true } );
  /**
   * @member {Mesh} mesh The mesh ready to get used in the scene
   */
  this.mesh = new Mesh( this.geometry, material );
  this.mesh.matrixAutoUpdate = false;
  /**
   * @member {Boolean} geometryNeedsUpdate If set to true, updateGeometry will be triggered at the next repaint
   */
  this.geometryNeedsUpdate = true;
  this.repaint().then( callback ).catch( e=>{

    throw e;

  } );

  /**
   * @member {Number} iLength Width of slice in the original coordinate system, corresponds to the width of the buffer canvas
   */

  /**
   * @member {Number} jLength Height of slice in the original coordinate system, corresponds to the height of the buffer canvas
   */

  /**
   * @member {Function} sliceAccess Function that allow the slice to access right data
   * @see Volume.extractPerpendicularPlane
   * @param {Number} i The first coordinate
   * @param {Number} j The second coordinate
   * @returns {Number} the index corresponding to the voxel in volume.data of the given position in the slice
   */


}

/**
 * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
 * @memberof VolumeSlice
 */
async repaint() {

  if ( this.geometryNeedsUpdate ) {

    this.updateGeometry();

  }

  const iLength = this.iLength,
    jLength = this.jLength,
    sliceAccess = this.sliceAccess,
    volume = this.volume,
    canvas = this.canvasBuffer,
    ctx = this.ctxBuffer;


  // get the imageData and pixel array from the canvas
  const imgData = ctx.getImageData( 0, 0, iLength, jLength );
  const data = imgData.data;
  const volumeData = volume.data;
  const upperThreshold = volume.upperThreshold;
  const lowerThreshold = volume.lowerThreshold;
  const windowLow = volume.windowLow;
  const windowHigh = volume.windowHigh;

  // manipulate some pixel elements
  let pixelCount = 0;

  if ( volume.dataType === 'label' ) {

    //this part is currently useless but will be used when colortables will be handled
    for ( let j = 0; j < jLength; j ++ ) {

      for ( let i = 0; i < iLength; i ++ ) {

        let label = volumeData[ sliceAccess( i, j ) ];
        label = label >= this.colorMap.length ? ( label % this.colorMap.length ) + 1 : label;
        const color = this.colorMap[ label ];
        data[ 4 * pixelCount ] = ( color >> 24 ) & 0xff;
        data[ 4 * pixelCount + 1 ] = ( color >> 16 ) & 0xff;
        data[ 4 * pixelCount + 2 ] = ( color >> 8 ) & 0xff;
        data[ 4 * pixelCount + 3 ] = color & 0xff;
        pixelCount ++;

      }

    }

  } else {

    for ( let j = 0; j < jLength; j ++ ) {

      for ( let i = 0; i < iLength; i ++ ) {

        let value = volumeData[ sliceAccess( i, j ) ];
        let alpha = 0xff;
        //apply threshold
        alpha = upperThreshold >= value ? ( lowerThreshold <= value ? alpha : 0 ) : 0;
        //apply window level
        value = Math.floor( 255 * ( value - windowLow ) / ( windowHigh - windowLow ) );
        value = value > 255 ? 255 : ( value < 0 ? 0 : value | 0 );

        data[ 4 * pixelCount ] = value;
        data[ 4 * pixelCount + 1 ] = value;
        data[ 4 * pixelCount + 2 ] = value;
        data[ 4 * pixelCount + 3 ] = alpha;
        pixelCount ++;

      }

    }

  }

   //core.Canvas.putImageData(ctx, imgData, 0, 0 );
   ctx.putImageData( imgData, 0, 0 );
  this.ctx.drawImage( (await core.Canvas.toImage(this.canvas,canvas)), 0, 0, iLength, jLength, 0, 0, this.canvas.width, this.canvas.height );


  this.mesh.material.map.needsUpdate = true;

}

/**
 * @member {Function} Refresh the geometry according to axis and index
 * @see Volume.extractPerpendicularPlane
 * @memberof VolumeSlice
 */
updateGeometry() {

  const extracted = this.volume.extractPerpendicularPlane( this.axis, this.index );
  this.sliceAccess = extracted.sliceAccess;
  this.jLength = extracted.jLength;
  this.iLength = extracted.iLength;
  this.matrix = extracted.matrix;

  this.canvas.width = extracted.planeWidth;
  this.canvas.height = extracted.planeHeight;
  this.canvasBuffer.width = this.iLength;
  this.canvasBuffer.height = this.jLength;
  this.ctx = this.canvas.getContext( '2d' );
  this.ctxBuffer = this.canvasBuffer.getContext( '2d' );

  if ( this.geometry ) this.geometry.dispose(); // dispose existing geometry

  this.geometry = new PlaneGeometry( extracted.planeWidth, extracted.planeHeight );

  if ( this.mesh ) {

    this.mesh.geometry = this.geometry;
    //reset mesh matrix
    this.mesh.matrix.identity();
    this.mesh.applyMatrix4( this.matrix );

  }

  this.geometryNeedsUpdate = false;

}

}

export { VolumeSlice };
